home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / CPP / WFC010.ZIP / SRC / CSMTF.CPP < prev    next >
C/C++ Source or Header  |  1995-12-07  |  18KB  |  664 lines
  1. #include <wfc.h>
  2. #pragma hdrstop
  3.  
  4. /*
  5. ** Author: Samuel R. Blackburn
  6. ** CI$: 76300,326
  7. ** Internet: sammy@sed.csc.com
  8. **
  9. ** You can use it any way you like as long as you don't try to sell it.
  10. **
  11. ** Any attempt to sell WFC in source code form must have the permission
  12. ** of the original author. You can produce commercial executables with
  13. ** WFC but you can't sell WFC.
  14. **
  15. ** Copyright, 1995, Samuel R. Blackburn
  16. **
  17. ** $Workfile: $
  18. ** $Revision: $
  19. ** $Modtime: $
  20. */
  21.  
  22. #if defined( _DEBUG )
  23. #undef THIS_FILE
  24. static char BASED_CODE THIS_FILE[] = __FILE__;
  25. #define new DEBUG_NEW
  26. #endif
  27.  
  28. /*
  29. ** CUINT64
  30. */
  31.  
  32. CUINT64::CUINT64()
  33. {
  34.    Empty();
  35. }
  36.  
  37. CUINT64::CUINT64( const CUINT64& source )
  38. {
  39.    Empty();
  40.    Copy( source );
  41. }
  42.  
  43. CUINT64::CUINT64( const UINT64 * source )
  44. {
  45.    Empty();
  46.    Copy( source );
  47. }
  48.  
  49. void CUINT64::Copy( const CUINT64& source )
  50. {
  51.    Copy( (const UINT64 *) &source );
  52. }
  53.  
  54. void CUINT64::Copy( const UINT64 * source )
  55. {
  56.    ASSERT( source != NULL );
  57.  
  58.    if ( source == NULL )
  59.    {
  60.       Empty();
  61.       return;
  62.    }
  63.  
  64.    lsw = source->lsw;
  65.    msw = source->msw;
  66. }
  67.  
  68. #if defined( _DEBUG )
  69.  
  70. void CUINT64::Dump( CDumpContext& dump_context ) const
  71. {
  72.    dump_context << " a CUINT64 at " << (void *) this << "\n";
  73.    dump_context << "{\n";
  74.    dump_context << "   lsw = " << lsw << "\n";
  75.    dump_context << "   msw = " << msw << "\n";
  76.    dump_context << "}\n";
  77. }
  78.  
  79. #endif // _DEBUG
  80.  
  81. void CUINT64::Empty( void )
  82. {
  83.    lsw = 0;
  84.    msw = 0;
  85. }
  86.  
  87. /*
  88. ** CMTFDateTime
  89. */
  90.  
  91. CMTFDateTime::CMTFDateTime()
  92. {
  93.    Empty();
  94. }
  95.  
  96. CMTFDateTime::CMTFDateTime( const CMTFDateTime& source )
  97. {
  98.    Empty();
  99.    Copy( source );
  100. }
  101.  
  102. CMTFDateTime::CMTFDateTime( const MTF_DATE_TIME * source )
  103. {
  104.    Empty();
  105.    Copy( source );
  106. }
  107.  
  108. void CMTFDateTime::Convert( CTime& destination ) const
  109. {
  110.    int year    = 0;
  111.    int month   = 0;
  112.    int day     = 0;
  113.    int hours   = 0;
  114.    int minutes = 0;
  115.    int seconds = 0;
  116.  
  117.    BYTE temp_byte = 0;
  118.  
  119.    /* Compressed date structure for storing dates in minimal space on tape
  120.    **  BYTE 0    BYTE 1    BYTE 2    BYTE 3    BYTE 4
  121.    ** 76543210  76543210  76543210  76543210  76543210
  122.    ** yyyyyyyy  yyyyyymm  mmdddddh  hhhhmmmm  mmssssss
  123.    */
  124.  
  125.    /*
  126.    ** Year
  127.    */
  128.  
  129.    temp_byte = dt_field[ 1 ];
  130.  
  131.    bit_clear( temp_byte, 0 );
  132.    bit_clear( temp_byte, 1 );
  133.  
  134.    year = ( 256 * dt_field[ 0 ] ) + temp_byte;
  135.  
  136.    TRACE( "CMTFDateTime::Convert() : year is %d\n", year );
  137.  
  138.    /*
  139.    ** Month
  140.    */
  141.  
  142.    temp_byte = dt_field[ 2 ] >> 6;
  143.  
  144.    month = ( dt_field[ 1 ] % 3 ) + temp_byte;
  145.  
  146.    TRACE( "CMTFDateTime::Convert() : month is %d\n", month );
  147.  
  148.    /*
  149.    ** Day
  150.    */
  151.  
  152.    temp_byte = dt_field[ 2 ];
  153.  
  154.    bit_clear( temp_byte, 7 );
  155.    bit_clear( temp_byte, 6 );
  156.  
  157.    day = temp_byte >> 1;
  158.  
  159.    TRACE( "CMTFDateTime::Convert() : day is %d\n", day );
  160.  
  161.    /*
  162.    ** Hours
  163.    */
  164.  
  165.    temp_byte = dt_field[ 3 ];
  166.  
  167.    hours = temp_byte >> 4;
  168.  
  169.    if ( bit_test( dt_field[ 2 ], 0 ) == 1 )
  170.    {
  171.       hours += 16;
  172.    }
  173.  
  174.    TRACE( "CMTFDateTime::Convert() : hours is %d\n", hours );
  175.  
  176.    /*
  177.    ** Minutes
  178.    */
  179.  
  180.    minutes = dt_field[ 4 ] >> 6;
  181.  
  182.    temp_byte = (BYTE) ( dt_field[ 3 ] % 16 );
  183.  
  184.    minutes += ( temp_byte << 2 );
  185.  
  186.    TRACE( "CMTFDateTime::Convert() : minutes is %d\n", minutes );
  187.  
  188.    /*
  189.    ** Seconds
  190.    */
  191.  
  192.    seconds = dt_field[ 4 ];
  193.  
  194.    bit_clear( seconds, 7 );
  195.    bit_clear( seconds, 6 );
  196.  
  197.    TRACE( "CMTFDateTime::Convert() : seconds is %d\n", seconds );
  198.  
  199.    destination = CTime( year, month, day, hours, minutes, seconds );
  200. }
  201.  
  202. void CMTFDateTime::Copy( const CTime& source )
  203. {
  204.    return;
  205. }
  206.  
  207. void CMTFDateTime::Copy( const CMTFDateTime& source )
  208. {
  209.    Copy( (const MTF_DATE_TIME *) &source );
  210. }
  211.  
  212. void CMTFDateTime::Copy( const MTF_DATE_TIME * source )
  213. {
  214.    ASSERT( source != NULL );
  215.  
  216.    if ( source == NULL )
  217.    {
  218.       Empty();
  219.       return;
  220.    }
  221.  
  222.    int index = 0;
  223.  
  224.    while( index < sizeof( dt_field ) )
  225.    {
  226.       dt_field[ index ] = source->dt_field[ index ];
  227.       index++;
  228.    }
  229. }
  230.  
  231. #if defined( _DEBUG )
  232.  
  233. void CMTFDateTime::Dump( CDumpContext& dump_context ) const
  234. {
  235.    dump_context << " a CMTFDateTime at " << (void *) this << "\n";
  236.    dump_context << "{\n";
  237.    dump_context << "   dt_field[ 0 ] = " << dt_field[ 0 ] << "\n";
  238.    dump_context << "   dt_field[ 1 ] = " << dt_field[ 1 ] << "\n";
  239.    dump_context << "   dt_field[ 2 ] = " << dt_field[ 2 ] << "\n";
  240.    dump_context << "   dt_field[ 3 ] = " << dt_field[ 3 ] << "\n";
  241.    dump_context << "   dt_field[ 4 ] = " << dt_field[ 4 ] << "\n";
  242.    dump_context << "}\n";
  243. }
  244.  
  245. #endif // _DEBUG
  246.  
  247. void CMTFDateTime::Empty( void )
  248. {
  249.    dt_field[ 0 ] = 0;
  250.    dt_field[ 1 ] = 0;
  251.    dt_field[ 2 ] = 0;
  252.    dt_field[ 3 ] = 0;
  253.    dt_field[ 4 ] = 0;
  254. }
  255.  
  256. /*
  257. ** CMTFTapeAddress
  258. */
  259.  
  260. CMTFTapeAddress::CMTFTapeAddress()
  261. {
  262.    Empty();
  263. }
  264.  
  265. CMTFTapeAddress::CMTFTapeAddress( const CMTFTapeAddress& source )
  266. {
  267.    Empty();
  268.    Copy( source );
  269. }
  270.  
  271. CMTFTapeAddress::CMTFTapeAddress( const MTF_TAPE_ADDRESS * source )
  272. {
  273.    Empty();
  274.    Copy( source );
  275. }
  276.  
  277. void CMTFTapeAddress::Copy( const CMTFTapeAddress& source )
  278. {
  279.    Copy( (const MTF_TAPE_ADDRESS *) &source );
  280. }
  281.  
  282. void CMTFTapeAddress::Copy( const MTF_TAPE_ADDRESS * source )
  283. {
  284.    ASSERT( source != NULL );
  285.  
  286.    if ( source == NULL )
  287.    {
  288.       Empty();
  289.       return;
  290.    }
  291.  
  292.    elmdata_size = source->elmdata_size;
  293.    data_offset = source->data_offset;
  294. }
  295.  
  296. #if defined( _DEBUG )
  297.  
  298. void CMTFTapeAddress::Dump( CDumpContext& dump_context ) const
  299. {
  300.    dump_context << " a CMTFTapeAddress at " << (void *) this << "\n";
  301.    dump_context << "{\n";
  302.    dump_context << "   elmdata_size = " << elmdata_size << "\n";
  303.    dump_context << "   data_offset = " << data_offset << "\n";
  304.    dump_context << "}\n";
  305. }
  306.  
  307. #endif // _DEBUG
  308.  
  309. void CMTFTapeAddress::Empty( void )
  310. {
  311.    elmdata_size = 0;
  312.    data_offset  = 0;
  313. }
  314.  
  315. /*
  316. ** CMTFDataBlockHeader
  317. */
  318.  
  319. CMTFDataBlockHeader::CMTFDataBlockHeader()
  320. {
  321.    Empty();
  322. }
  323.  
  324. CMTFDataBlockHeader::CMTFDataBlockHeader( const CMTFDataBlockHeader& source )
  325. {
  326.    Empty();
  327.    Copy( source );
  328. }
  329.  
  330. CMTFDataBlockHeader::CMTFDataBlockHeader( const MTF_DB_HDR * source )
  331. {
  332.    Empty();
  333.    Copy( source );
  334. }
  335.  
  336. void CMTFDataBlockHeader::Copy( const CMTFDataBlockHeader& source )
  337. {
  338.    Copy( (const MTF_DB_HDR *) &source );
  339. }
  340.  
  341. void CMTFDataBlockHeader::Copy( const MTF_DB_HDR * source )
  342. {
  343.    ASSERT( source != NULL );
  344.  
  345.    if ( source == NULL )
  346.    {
  347.       Empty();
  348.       return;
  349.    }
  350.  
  351.    block_type[ 0 ] = source->block_type[ 0 ];
  352.    block_type[ 1 ] = source->block_type[ 1 ];
  353.    block_type[ 2 ] = source->block_type[ 2 ];
  354.    block_type[ 3 ] = source->block_type[ 3 ];
  355.  
  356.    block_attribs      = source->block_attribs;
  357.    offset_to_data     = source->offset_to_data;
  358.    machine_os_id      = source->machine_os_id;
  359.    machine_os_version = source->machine_os_version;
  360.  
  361.    displayable_size.lsw = source->displayable_size.lsw;
  362.    displayable_size.msw = source->displayable_size.msw;
  363.  
  364.    logical_block_address.lsw = source->logical_block_address.lsw;
  365.    logical_block_address.msw = source->logical_block_address.msw;
  366.  
  367.    session_id.lsw = source->session_id.lsw;
  368.    session_id.msw = source->session_id.msw;
  369.  
  370.    control_block_id = source->control_block_id;
  371.    
  372.    string_storage.elmdata_size = source->string_storage.elmdata_size;
  373.    string_storage.data_offset  = source->string_storage.data_offset;
  374.  
  375.    os_specific_data.elmdata_size = source->os_specific_data.elmdata_size;
  376.    os_specific_data.data_offset  = source->os_specific_data.data_offset;
  377.  
  378.    string_type = source->string_type;
  379.    reserved    = source->reserved;
  380.    hdr_chksm   = source->hdr_chksm;
  381. }
  382.  
  383. #if defined( _DEBUG )
  384.  
  385. void CMTFDataBlockHeader::Dump( CDumpContext& dump_context ) const
  386. {
  387.    TCHAR block_type_string[ 5 ];
  388.    CMTFTapeAddress tape_address;
  389.    CUINT64 temp_uint;
  390.  
  391.    block_type_string[ 0 ] = block_type[ 0 ];
  392.    block_type_string[ 1 ] = block_type[ 1 ];
  393.    block_type_string[ 2 ] = block_type[ 2 ];
  394.    block_type_string[ 3 ] = block_type[ 3 ];
  395.    block_type_string[ 4 ] = 0x00;
  396.  
  397.    dump_context << " a CMTFDataBlockHeader at " << (void *) this << "\n";
  398.    dump_context << "{\n";
  399.    dump_context << "   block_type[4]      = " << block_type_string  << "\n";
  400.    dump_context << "   block_attribs      = " << block_attribs      << "\n";
  401.    dump_context << "   offset_to_data     = " << offset_to_data     << "\n";
  402.    dump_context << "   machine_os_id      = " << machine_os_id      << "\n";
  403.    dump_context << "   machine_os_version = " << machine_os_version << "\n";
  404.  
  405.    dump_context << "   displayable_size is";
  406.    temp_uint.Copy( &displayable_size );
  407.    temp_uint.Dump( dump_context );
  408.  
  409.    dump_context << "   logical_block_address is";
  410.    temp_uint.Copy( &logical_block_address );
  411.    temp_uint.Dump( dump_context );
  412.  
  413.    dump_context << "   session_id is";
  414.    temp_uint.Copy( &session_id );
  415.    temp_uint.Dump( dump_context );
  416.    dump_context << "   control_block_id = " << control_block_id << "\n";
  417.    dump_context << "   string_storage is";
  418.    tape_address.Copy( &string_storage );
  419.    tape_address.Dump( dump_context );
  420.    
  421.    dump_context << "   os_specific_data is";
  422.    tape_address.Copy( &string_storage );
  423.    tape_address.Dump( dump_context );
  424.  
  425.    dump_context << "   string_type = " << string_type << "\n";
  426.    dump_context << "   reserved    = " << reserved    << "\n";
  427.    dump_context << "   hdr_chksm   = " << hdr_chksm   << "\n";
  428.    dump_context << "}\n";
  429. }
  430.  
  431. #endif // _DEBUG
  432.  
  433. void CMTFDataBlockHeader::Empty( void )
  434. {
  435.    block_type[ 0 ] = 0;
  436.    block_type[ 1 ] = 0;
  437.    block_type[ 2 ] = 0;
  438.    block_type[ 3 ] = 0;
  439.  
  440.    block_attribs      = 0;
  441.    offset_to_data     = 0;
  442.    machine_os_id      = 0;
  443.    machine_os_version = 0;
  444.  
  445.    displayable_size.lsw = 0;
  446.    displayable_size.msw = 0;
  447.  
  448.    logical_block_address.lsw = 0;
  449.    logical_block_address.msw = 0;
  450.  
  451.    session_id.lsw = 0;
  452.    session_id.msw = 0;
  453.  
  454.    control_block_id = 0;
  455.    
  456.    string_storage.elmdata_size = 0;
  457.    string_storage.data_offset  = 0;
  458.  
  459.    os_specific_data.elmdata_size = 0;
  460.    os_specific_data.data_offset  = 0;
  461.  
  462.    string_type = 0;
  463.    reserved    = 0;
  464.    hdr_chksm   = 0;
  465. }
  466.  
  467. /*
  468. ** CMTFTape
  469. */
  470.  
  471. CMTFTape::CMTFTape()
  472. {
  473.    Empty();
  474. }
  475.  
  476. CMTFTape::CMTFTape( const CMTFTape& source )
  477. {
  478.    Empty();
  479.    Copy( source );
  480. }
  481.  
  482. CMTFTape::CMTFTape( const MTF_TAPE * source )
  483. {
  484.    Empty();
  485.    Copy( source );
  486. }
  487.  
  488. void CMTFTape::Copy( const CMTFTape& source )
  489. {
  490.    Copy( (const MTF_TAPE *) &source );
  491. }
  492.  
  493. void CMTFTape::Copy( const MTF_TAPE * source )
  494. {
  495.    ASSERT( source != NULL );
  496.  
  497.    if ( source == NULL )
  498.    {
  499.       Empty();
  500.       return;
  501.    }
  502.  
  503.    block_header.block_type[ 0 ] = source->block_header.block_type[ 0 ];
  504.    block_header.block_type[ 1 ] = source->block_header.block_type[ 1 ];
  505.    block_header.block_type[ 2 ] = source->block_header.block_type[ 2 ];
  506.    block_header.block_type[ 3 ] = source->block_header.block_type[ 3 ];
  507.  
  508.    block_header.block_attribs      = source->block_header.block_attribs;
  509.    block_header.offset_to_data     = source->block_header.offset_to_data;
  510.    block_header.machine_os_id      = source->block_header.machine_os_id;
  511.    block_header.machine_os_version = source->block_header.machine_os_version;
  512.  
  513.    block_header.displayable_size.lsw = source->block_header.displayable_size.lsw;
  514.    block_header.displayable_size.msw = source->block_header.displayable_size.msw;
  515.  
  516.    block_header.logical_block_address.lsw = source->block_header.logical_block_address.lsw;
  517.    block_header.logical_block_address.msw = source->block_header.logical_block_address.msw;
  518.  
  519.    block_header.session_id.lsw = source->block_header.session_id.lsw;
  520.    block_header.session_id.msw = source->block_header.session_id.msw;
  521.  
  522.    block_header.control_block_id = source->block_header.control_block_id;
  523.    
  524.    block_header.string_storage.elmdata_size = source->block_header.string_storage.elmdata_size;
  525.    block_header.string_storage.data_offset  = source->block_header.string_storage.data_offset;
  526.  
  527.    block_header.os_specific_data.elmdata_size = source->block_header.os_specific_data.elmdata_size;
  528.    block_header.os_specific_data.data_offset  = source->block_header.os_specific_data.data_offset;
  529.  
  530.    block_header.string_type = source->block_header.string_type;
  531.    block_header.reserved    = source->block_header.reserved;
  532.    block_header.hdr_chksm   = source->block_header.hdr_chksm;
  533.  
  534.    tape_id_number            = source->tape_id_number;
  535.    tape_attributes           = source->tape_attributes;
  536.    tape_seq_number           = source->tape_seq_number;
  537.    password_encryption_algor = source->password_encryption_algor;
  538.    ecc_alg                   = source->ecc_alg;
  539.    otc_type                  = source->otc_type;
  540.  
  541.    tape_name.elmdata_size = source->tape_name.elmdata_size;
  542.    tape_name.data_offset  = source->tape_name.data_offset;
  543.  
  544.    tape_description.elmdata_size = source->tape_description.elmdata_size;
  545.    tape_description.data_offset  = source->tape_description.data_offset;
  546.  
  547.    tape_password.elmdata_size = source->tape_password.elmdata_size;
  548.    tape_password.data_offset  = source->tape_password.data_offset;
  549.  
  550.    software_name.elmdata_size = source->software_name.elmdata_size;
  551.    software_name.data_offset  = source->software_name.data_offset;
  552.  
  553.    logical_block_size = source->logical_block_size;
  554.    software_vendor_id = source->software_vendor_id;
  555.    
  556.    tape_date.dt_field[ 0 ] = source->tape_date.dt_field[ 0 ];
  557.    tape_date.dt_field[ 1 ] = source->tape_date.dt_field[ 1 ];
  558.    tape_date.dt_field[ 2 ] = source->tape_date.dt_field[ 2 ];
  559.    tape_date.dt_field[ 3 ] = source->tape_date.dt_field[ 3 ];
  560.    tape_date.dt_field[ 4 ] = source->tape_date.dt_field[ 4 ];
  561.  
  562.    tape_format_version_major = source->tape_format_version_major;
  563. }
  564.  
  565. #if defined( _DEBUG )
  566.  
  567. void CMTFTape::Dump( CDumpContext& dump_context ) const
  568. {
  569.    dump_context << " a CMTFDataBlockHeader at " << (void *) this << "\n";
  570.    dump_context << "{\n";
  571.    CMTFDataBlockHeader header( &block_header );
  572.    dump_context << "   block_header is";
  573.    header.Dump( dump_context );
  574.    dump_context << "   tape_id_number                = " << tape_id_number                << "\n";
  575.    dump_context << "   tape_attributes               = " << tape_attributes               << "\n";
  576.    dump_context << "   tape_seq_number               = " << tape_seq_number               << "\n";
  577.    dump_context << "   password_encryption_algor     = " << password_encryption_algor     << "\n";
  578.    dump_context << "   ecc_alg                       = " << ecc_alg                       << "\n";
  579.    dump_context << "   otc_type                      = " << otc_type                      << "\n";
  580.    dump_context << "   tape_name.elmdata_size        = " << tape_name.elmdata_size        << "\n";
  581.    dump_context << "   tape_name.data_offset         = " << tape_name.data_offset         << "\n";
  582.    dump_context << "   tape_description.elmdata_size = " << tape_description.elmdata_size << "\n";
  583.    dump_context << "   tape_description.data_offset  = " << tape_description.data_offset  << "\n";
  584.    dump_context << "   tape_password.elmdata_size    = " << tape_password.elmdata_size    << "\n";
  585.    dump_context << "   tape_password.data_offset     = " << tape_password.data_offset     << "\n";
  586.    dump_context << "   software_name.elmdata_size    = " << software_name.elmdata_size    << "\n";
  587.    dump_context << "   software_name.data_offset     = " << software_name.data_offset     << "\n";
  588.    dump_context << "   logical_block_size            = " << logical_block_size            << "\n";
  589.    dump_context << "   software_vendor_id            = " << software_vendor_id            << "\n";
  590.    dump_context << "   tape_date.dt_field[ 0 ]       = " << tape_date.dt_field[ 0 ]       << "\n";
  591.    dump_context << "   tape_date.dt_field[ 1 ]       = " << tape_date.dt_field[ 1 ]       << "\n";
  592.    dump_context << "   tape_date.dt_field[ 2 ]       = " << tape_date.dt_field[ 2 ]       << "\n";
  593.    dump_context << "   tape_date.dt_field[ 3 ]       = " << tape_date.dt_field[ 3 ]       << "\n";
  594.    dump_context << "   tape_date.dt_field[ 4 ]       = " << tape_date.dt_field[ 4 ]       << "\n";
  595.    dump_context << "   tape_format_version_major     = " << tape_format_version_major     << "\n";
  596.    dump_context << "}\n";
  597. }
  598.  
  599. #endif // _DEBUG
  600.  
  601. void CMTFTape::Empty( void )
  602. {
  603.    block_header.block_type[ 0 ] = 0;
  604.    block_header.block_type[ 1 ] = 0;
  605.    block_header.block_type[ 2 ] = 0;
  606.    block_header.block_type[ 3 ] = 0;
  607.  
  608.    block_header.block_attribs      = 0;
  609.    block_header.offset_to_data     = 0;
  610.    block_header.machine_os_id      = 0;
  611.    block_header.machine_os_version = 0;
  612.  
  613.    block_header.displayable_size.lsw = 0;
  614.    block_header.displayable_size.msw = 0;
  615.  
  616.    block_header.logical_block_address.lsw = 0;
  617.    block_header.logical_block_address.msw = 0;
  618.  
  619.    block_header.session_id.lsw = 0;
  620.    block_header.session_id.msw = 0;
  621.  
  622.    block_header.control_block_id = 0;
  623.    
  624.    block_header.string_storage.elmdata_size = 0;
  625.    block_header.string_storage.data_offset  = 0;
  626.  
  627.    block_header.os_specific_data.elmdata_size = 0;
  628.    block_header.os_specific_data.data_offset  = 0;
  629.    block_header.string_type = 0;
  630.    block_header.reserved    = 0;
  631.    block_header.hdr_chksm   = 0;
  632.  
  633.    tape_id_number            = 0;
  634.    tape_attributes           = 0;
  635.    tape_seq_number           = 0;
  636.    password_encryption_algor = 0;
  637.    ecc_alg                   = 0;
  638.    otc_type                  = 0;
  639.  
  640.    tape_name.elmdata_size = 0;
  641.    tape_name.data_offset  = 0;
  642.  
  643.    tape_description.elmdata_size = 0;
  644.    tape_description.data_offset  = 0;
  645.  
  646.    tape_password.elmdata_size = 0;
  647.    tape_password.data_offset  = 0;
  648.  
  649.    software_name.elmdata_size = 0;
  650.    software_name.data_offset  = 0;
  651.  
  652.    logical_block_size = 0;
  653.    software_vendor_id = 0;
  654.    
  655.    tape_date.dt_field[ 0 ] = 0;
  656.    tape_date.dt_field[ 1 ] = 0;
  657.    tape_date.dt_field[ 2 ] = 0;
  658.    tape_date.dt_field[ 3 ] = 0;
  659.    tape_date.dt_field[ 4 ] = 0;
  660.  
  661.    tape_format_version_major = 0;
  662. }
  663.  
  664.